package collector.core.util;

import java.io.File;
import java.io.UnsupportedEncodingException;

import org.apache.commons.lang.ArrayUtils;

/**
 * <pre>
 * Class : collector.util.StringUtil / StringUtil.java
 * 	Define Class Object : String 관련 처리 Util Method 구현 
 * <br>
 * </pre>
 * @author ytjeong / apexcns,Inc.
 * @version 1.0
 * @see javadoc
 * @since 2012. 9. 12.
 */
public class StringUtil {
	public static String convertColumnData(String str, int flag) {
		String tempStr = StringUtil.rTrim(str);
		tempStr = StringUtil.replaceAll(tempStr, "|", "^");
		tempStr = StringUtil.replaceAll(tempStr, "\r", " ");
		tempStr = StringUtil.replaceAll(tempStr, "\n", " ");
		if (tempStr.length() > 509 && flag == 1) {
			tempStr = StringUtil.getLeftByteString(tempStr, 509);
		}
		
		return tempStr;
	}
	
	public static boolean isNumber(String number) {
		boolean flag = true;
		if (number == null || "".equals(number))
			return false;

		int size = number.length();
		int st_no = 0;

		// 음수인지 아닌지 판별 . 음수면 시작위치를 1부터
		if (number.charAt(0) == 45)
			st_no = 1;

		for (int i = st_no; i < size; ++i) {
			if (!(48 <= ((int) number.charAt(i)) && 57 >= ((int) number.charAt(i)))) {
				flag = false;
				break;
			}
		}
		return flag;
	}
	
	/**
	 * @see 오른쪽의 공백을 제거한다.
	 */
	public static final String rTrim(String s) {
		try {
			char[] val = s.toCharArray();
			int pos = val.length;

			while ((pos > 0) && ((val[pos - 1] <= ' ') || (val[pos-1] == '\t')))	pos--;

			return ( pos < val.length ) ? s.substring(0, pos) : s;
		} catch ( Exception e ) {
			return "";
		}
	}
	
	/**
     * <pre>
     * 입력 받은 모든 문자를 변경한다.
     * 자바 1.3 대응 replaceAll method
     * - ATC장일홍대리버젼 -
     * </pre>
     * @param prSrc 소스스트링
     * @param FindStr 대상스트링
     * @param ChgStr 변환스트링
     * @return String 변화스트링으로 치환된 스트링을 리턴한다.
     */
    public static String replaceAll(String prSrc, String FindStr, String ChgStr) {
		int FindPos = 0;

		String RetStr = prSrc;
		while ( RetStr.indexOf(FindStr,0) != -1 ) {
		    FindPos = RetStr.indexOf(FindStr,0);
		    RetStr = RetStr.substring(0,FindPos) + ChgStr + RetStr.substring(FindPos + FindStr.length(),RetStr.length());
		}
		return RetStr;
    }
    
    /** byte수 길이만큼 왼쪽부터 문자열을 잘라옴 */
	public static String getLeftByteString(String str, int len) {
		String ret = "";
		char[] chars = str.toCharArray();
		int idx = 0;
		for(idx=0; idx<chars.length && len>0; idx++) {
			String s = String.valueOf(chars[idx]);
			len -= s.getBytes().length;
			//if (chars[idx]>=0xAC00 && chars[idx]<=0xD7A3) {
		}
		ret = new String(ArrayUtils.subarray(chars, 0, len<0 ? idx-1 : idx));
		if(len<0) ret += rpad("", Math.abs(len));
		return ret;
	}
	
	static final char FS = File.separatorChar;
	static final String FSStr = String.valueOf(File.separatorChar);
	/**
	 * 문자열이 비어 있는지 체크한다.
	 */
	public static boolean isEmpty(String str) {
		return str==null || "".equals(str);
	}

	public static String nvl(String str) {
	    return str==null ? "" : str;
	}

	public static String nvl(Object obj) {
	    return obj==null ? "" : nvl(String.valueOf(obj));
	}

	public static String nvl(String str, String def) {
	    return (str != null && !"".equals(str)) ? str : def;
	}

	public static String nvl(Object obj, String def) {
	    return obj==null ? "" : nvl(String.valueOf(obj), def);
	}

	public static double nvl(Object source,double value) {
		return nvl(String.valueOf(source), value);
	}

	public static float nvl(Object source,float value) {
		return nvl(String.valueOf(source), value);
	}

	public static int nvl(Object source,int value) {
		return nvl(String.valueOf(source), value);
	}

	public static double nvl(String src, double def) {
		try {
			return src==null ? def : Double.parseDouble(src);
		} catch (Exception e) {
			return def;
		}
	}

	public static float nvl(String src, float def) {
		try {
			return src==null ? def : Float.parseFloat(src);
		} catch (Exception e) {
			return def;
		}
	}

	public static long nvl(String src, long def) {
		try {
			return src==null ? def : Long.parseLong(src);
		} catch (Exception e) {
			return def;
		}
	}

	public static int nvl(String src, int def) {
		try {
			return src==null ? def : Integer.parseInt(src);
		} catch (Exception e) {
			return def;
		}
	}

	/**
	 * 문자열 왼쪽에 원하는 수만큼의 문자를 붙여서 리턴한다.
	 * @param str 기본 문자열
	 * @param i   리턴받는 문자열의 길이
	 * @param padStr 왼쪽에 포함되는 문자
	 * @return reStr 리턴 받을 문자열
	 */
	public static String lpad(String str, int i, String padStr) {
		String rtnStr = "";

		if (str == null || i == 0) {
			return str;
		} else {
			rtnStr = str;
		}

		for (int j = str.length(); j < i; j++) {
			rtnStr = padStr + rtnStr;
		}

		if (rtnStr.length() == i) {
			return rtnStr;
		} else {
			return str;
		}
	}
	
	/** 문자열 오른쪽에 원하는 수만큼의 공백를 붙여서 리턴한다. */
	public static String rpad(String str, int cnt) {
		return rpad(str, cnt, " ");
	}

	/** 문자열 오른쪽에 원하는 수만큼의 문자를 붙여서 리턴한다. */
	public static String rpad(String str, int cnt, String padStr) {
		if(str==null) str = "";
		while (str.length() < cnt) {
			str =  str + padStr;
		}
		return str;
	}
	
	/** byte[]를 문자열로 표현 */
	public static String toHexString(byte[] bytes) {
		if (bytes == null) return null;

		StringBuffer strb = new StringBuffer(bytes.length);
	    for (int i=0; i<bytes.length; i++) {
	    	strb.append(toHexString(bytes[i]));
		}

		return strb.toString();
	}

	/** byte를 문자열로 표현 */
	public static String toHexString(byte b) {
		int c = b & 0xff;
		return (c<16 ? "0" : "") + Integer.toHexString(c);
	}

	/**
	 * 문자열 인코딩 (8859_1 to UTF-8)
	 * @param str
	 * @return
	 */
	public static String encodeString(String str) {
		try {
			return new String(str.getBytes("8859_1"), "UTF-8");
		} catch (UnsupportedEncodingException e) {
			return str;
		}
	}
	
	/**
	 * 문자열 인코딩
	 * @param str
	 * @param source
	 * @param target
	 * @return
	 */
	public static String encodeString(String str, String source, String target) {
		try {
			return new String(str.getBytes(source), target);
		} catch (UnsupportedEncodingException e) {
			return str;
		}
	}
	
	// New Added By Jeong 2012.09.18
	/** String배열을 원하는 prefix로 desplit함.
	 * @param strArr
	 * @param prefix
	 * @return String
	 */
	public static String desplitStr(String[] strArr, char prefix) {
		String rtnStr = "";
		if(strArr != null)
			for(int i=0; i < strArr.length; i++)
				rtnStr += ("'"+strArr[i]+"'"+(strArr.length-1!=i?prefix:""));
		return rtnStr;
	}


	// New Added By Jeong 2012.09.18
	/**  
	 * <pre>
	 *
	 * </pre>
	 * @author ANCTech,Inc.
	 *
	 * @param pString
	 * @return String
	 *
	 */
	public static String getString(String pString) {

	    if (isEmpty(pString)) pString = "";
		return pString;
	}

	    /**
	     * <pre>
	     * 입력받은 delimiter 수에 해당하는 스트링을 꺼낸다.
	     * index는 zero base 임.
	     * </pre>
	     * @param str 대상스트링
	     * @param delimiter 구분자
	     * @param index 구분자 순번
	     * @return String 구분자순번에 해당하는 스트링
	     */
	    public static final String getIndexString(String str, String delimiter, int index) {
	        int indexCount = 0;
	        int fromIndex = 0;
	        int toIndex = 0;

	        String retString = null;

	        try {
	            while((toIndex = str.indexOf(delimiter, fromIndex)) != -1) {
	                if(indexCount == index) {
	                    retString = str.substring(fromIndex, toIndex);
	                    break;
	                }
	                indexCount++;
	                fromIndex = toIndex+delimiter.length();
	            }

	            // 마지막 구분자 처리
	            if(retString == null && indexCount == index) {
	                retString = str.substring(fromIndex, str.length());
	            }
	        } catch(Exception e) {
	        }
	        return retString;
	    }
	
}